package com.cn.dim.controller;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import com.cn.dim.pojo.Chktask;
import com.cn.dim.pojo.User;
import com.cn.dim.service.ChkcountService;
import com.cn.dim.service.ChktaskService;
import com.cn.dim.service.UserService;
import com.cn.dim.utils.ExcelUtil;


@Controller
@RequestMapping("/report")
public class ReportController {

	@Resource
	private ChkcountService chkcountService;
	@Resource
	private ChktaskService chktaskService;
	@Resource
	private UserService userService;
	
	//固定写法，不用太追究
	@RequestMapping(value ="/chkcountExcel",method = RequestMethod.GET)
	@ResponseBody
	public void chkcountExcel(HttpServletRequest request,HttpServletResponse response,String stime,String etime,String chkpointid){
	
		//1：根据查询条件生成主数据
		List<Map<String,Object>> list=doChkcountExcel(request, response, stime, etime, chkpointid);
		//2：定义excel的表格的表头（列标题）
		List<String> title = new ArrayList<String>();//定义表头
		title.add("编号");
		title.add("巡查地点");
		title.add("规定巡查次数");
		title.add("实际巡查次数");
		title.add("正常次数");
		title.add("异常次数");
		//3：定义excel的文件名
		String fileName="巡查任务统计";//定义文件名
		//4：生成excel		
		ExcelUtil.createExcelChkCount(request, response, list, fileName, title);//生成excel
	}

	@RequestMapping(value ="/chktaskExcel",method = RequestMethod.GET)
	@ResponseBody
	public void chktaskExcel(HttpServletRequest request,HttpServletResponse response,String chkpointid,String chkpointname,String tdate,String timerange){
		Chktask ct=new Chktask();//为了凑后面调用函数的参数
		ct.setChkpointid(chkpointid);
		//1：定义excel的表格的表头（列标题），这个是需要动态生成，不同的巡查点，巡查项目是不一样的；定义文件第一行的标题
		List<Map<String,Object>> title_colName = new ArrayList<>();//定义表头
		String title_topic=chkpointname+"运行巡检记录";
	
		//2：根据查询条件生成主数据（并给表头与列名附值）
		List<Map<String,Object>> list=doChktaskExcel(request,response,ct,tdate,timerange,title_colName);
		//3：定义excel的文件名
		String fileName="巡查任务流水";//定义文件名
		//4：生成excel		
		ExcelUtil.createExcelChkTask(request, response, list, fileName, title_colName,title_topic );//生成excel
	}
	
	
	//主方法1，由页面传来的巡查点下拉框中的参数决定是查全部检查点，还是单一检查点；
	public List<Map<String,Object>> doChkcountExcel (HttpServletRequest request,HttpServletResponse response,String stime,String etime,String chkpointid){
//第一部分：生成结果集数据，代码与chkcount逻辑完全相同
		Map<String,Object> t_Map=new HashMap<>();//定义空参数
		Map<String,Object> re_Map=new HashMap<>();//定义大返回值
 		List<Map<String,Object>> re_List = new ArrayList<>();//定义表格数据集
 		int rowDataNum=0;//用于导出excel时文件中的编号列
//情况1：stime（""）    etime（""）  chkpointid（""）
		//如果参数都是空，表示查询所有记录，需要先取得巡查点的id集合，然后循环集合，从而获取每个巡查点的数据（如果没有数据则不显示）有的话则取到stime（后缀置为“ 00:00:00”），
		//etime则取今天（后缀置为“ 23:59:59”），然后调用queryChkcountOne函数（传入上述3个参数）
 		if(stime==null){stime="";}
 		if(etime==null){etime="";}
 		if(chkpointid==null){chkpointid="";}
		if(stime.equals("")&&etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
//情况2：stime（""）    etime（√）  chkpointid（""）
		if(stime.equals("")&&!etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
		
//情况3：stime（""）    etime（""）  chkpointid（√）
		if(stime.equals("")&&etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){//由于chkpointid给定，这里只有1条记录
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
		
//情况4：stime（""）    etime（√）  chkpointid（√）
		if(stime.equals("")&&!etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况5：stime（√）    etime（""）  chkpointid（""）
		if(!stime.equals("")&&etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况6：stime（√）    etime（""）  chkpointid（√）
		if(!stime.equals("")&&etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况7：stime（√）    etime（√）  chkpointid（""）
		if(!stime.equals("")&&!etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况8：stime（√）    etime（√）  chkpointid（√）
		if(!stime.equals("")&&!etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))//如果截止时间要早于开始时间，也不产生记录
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				m_chkcountOne.put("rowDataNum", rowDataNum+=1);//用于导出excel时文件中的编号列
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
		
		return re_List;
	}
	
    
	//主方法2，对单一检查点进行统计汇总，再拼成map格式的list，参数是页面的查询条件
	public Map<String,Object> queryChkcountOne(String stime,String etime,String chkpointid){
		Map<String,Object> param=new HashMap<>();//定义查询参数
		Map<String,Object> reMap=new HashMap<>();//定义返回值
		//当参数都存在并且有效时
		//1：取该巡查点定义的每日巡查次数，进而计算出该时间段内的规定巡查次数；
		param.put("chkpointid", chkpointid);
		List<Map<String,Object>> list_defTime=chkcountService.queryDefTime(param);
		
		int defNum=Integer.parseInt((String)(list_defTime.get(0).get("timesineveryday")));
		int days=getDayNum(stime,etime);
		int allDefNum=defNum*days;
		reMap.put("allDefNum", allDefNum);
		
		//2：取得该巡查点，该时间段内的实际巡查次数；
		param.put("stime", stime);
		param.put("etime", etime);
		int realNum=chkcountService.queryReaTime(param);
		reMap.put("realNum", realNum);
		
		//3：取得该巡查点，该时间段内的结果正常的次数；
		int okNum=chkcountService.queryOkTime(param);
		reMap.put("okNum", okNum);
		
		//4：取得该巡查点，该时间段内的结果异常的次数；
		int errNum=chkcountService.queryErrTime(param);
		reMap.put("errNum", errNum);
		
		return reMap;
	}
	
    /**
	 * 作用： 适用于只选择了截止时间，如果截止时间要早于计算出的开始时间，则不产生记录；
	 * 参数：页面带过来的开始日期（stime必须在调用前判断为有效的时间字符串，格式为yyyy-MM-dd HH:mm:ss）
	 * 更新时间：2018-12-29
	 */
    public boolean isPastDate(String stime,String etime)
    {
        boolean flag = false;
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try 
		{
			Date sDate = sdf.parse(stime);
			Date eDate = sdf.parse(etime);
			flag = eDate.before(sDate);
		} 
		catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        return flag;
    }
    
    /**
	 * 作用：获取当前日期的yyyy-MM-dd 23:59:59格式字符串
	 * 参数：
	 * 更新时间：
	 */
    public String getCdate()
    {
    	String cdate_s="";
    	try 
		{
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			cdate_s = sdf.format(new Date());
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
    	return cdate_s+" 23:59:59";
    }
    
    /**
	 * 作用：获取两个时间之间的天数，如果是同一日期，则认为是1
	 * 参数：开始时间与截止时间
	 * 更新时间：
	 */
    public int getDayNum(String stime,String etime)
    {
        int timeDistance = 0 ;
    	try 
		{
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
			Date st=sdf.parse(stime);
			Date et=sdf.parse(etime);

	        Calendar c_st=Calendar.getInstance();
	        c_st.setTime(st);
	        
	        Calendar c_et=Calendar.getInstance();
	        c_et.setTime(et);
		
	    	int day_st=c_st.get(Calendar.DAY_OF_YEAR);
	        int day_et=c_et.get(Calendar.DAY_OF_YEAR);
	        
	        int year_st=c_st.get(Calendar.YEAR);
	        int year_et=c_et.get(Calendar.YEAR);
	        if(year_st != year_et) //不在同一年
	        {
	            for(int i = year_st ; i < year_et ; i ++)
	            {
	                if(i%4==0 && i%100!=0 || i%400==0)    //闰年            
	                {
	                    timeDistance+=366;
	                }
	                else    //不是闰年
	                {
	                    timeDistance+=365;
	                }
	            }
	            timeDistance=timeDistance+(day_et-day_st) ;
	        }
	        else//同年
	        {
	            timeDistance=day_et-day_st;
	        }
		}
    	catch (Exception e)
    	{
			// TODO: handle exception
			e.printStackTrace();
		}
    	return timeDistance+1;
    }

	public List<Map<String,Object>> doChktaskExcel(HttpServletRequest request,HttpServletResponse response,Chktask ct,String tdate,String timerange,List<Map<String,Object>> title_colName){
		Map<String,Object> param=new HashMap<>();//定义查询参数
 		List<Map<String,Object>> re_List = new ArrayList<>();//定义查询结果集
 		List<Map<String,Object>> table_List = new ArrayList<>();//定义表格数据集
		//参数ct是列表页中以查询条件数据临时组成的过渡chktask对象
		param.put("chktask", ct);//只保存一个检查点id的参数（外键chkpointid）
		
		//处理第二个参数“日期查询条件”，处理为所选择日期的00:00:00到下一日期的00:00:00
		param.put("tdate", tdate);//第二个查询参数
		if(tdate!=null)
		{
			if(tdate.equals(""))
			{
				param.put("tdate", null);//xml中的判断条件
			}
			else
			{
				String stime=tdate+" 00:00:00";
				String etime=tdate+" 23:59:59";
				param.put("stime", stime);//开始时间
				param.put("etime", etime);//截止时间
			}
		}
		
		//处理第三个参数“时间段范围类型查询条件”，处理为当前日期的23:59:59，往前推1天，1周，1月，1年的那天的00:00:00
		param.put("timerange", timerange);//第三个查询参数
		if(timerange!=null)
		{
			if(timerange.equals("0")||timerange.equals(""))
			{
				param.put("timerange", null);//xml中的判断条件
			}
			else
			{
				String[] startTimeAndEndTime=getStimeAndEtime(timerange); 
				param.put("stimerange", startTimeAndEndTime[0]);//周期开始时间
				param.put("etimerange", startTimeAndEndTime[1]);//周期截止时间
			}
		}
		
		try {
			re_List = chktaskService.queryChktaskExcel(param);
			if(re_List.size()>0)
			{
				Map<String,Object> m=re_List.get(0);
				String datarecord=(String)m.get("datarecord");//取得数据库中的原始数据（json格式）
				createTitle_colName(datarecord, title_colName);
			}
			
			//下面代码通过循环对每一行的结果集补充“本次巡查数据”这个显示字段
			for(Map m:re_List){
				Map<String,Object> table_m=new HashMap<>();//按照顺序构造表格数据
				table_m.put("chktime", m.get("chktime"));//时间
				String datarecord=(String)m.get("datarecord");//取得数据库中的原始数据（json格式）
				getChkdetail(datarecord,table_m);//若干巡查项（按照json中的顺序保存）
				table_m.put("name", m.get("name"));//巡检员（巡查人）
				table_m.put("chkdes", m.get("chkdes"));//备注
				
				table_List.add(table_m);//
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		return table_List;
	}
	
	//解析json格式的datarecord字段用于导出excel的列显示，生成每一行的导出数据（辅助方法）
	private void getChkdetail(String datarecord,Map<String,Object> table_m)
	{
		try {
		    JSONArray array = JSONArray.fromObject(datarecord);
		    for (int i = 0; i < array.size(); i++) {
		        JSONObject jsonObject = array.getJSONObject(i);
		        String iv = jsonObject.getString("itemvalue");//通过键值名获取字符串
		        table_m.put("para"+i, iv);//保存每个检查点不同的检查项参数
		    }
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	//解析json格式的datarecord字段用于导出excel的列标题名（辅助方法）
	private void createTitle_colName(String datarecord,List<Map<String,Object>> title_colName)
	{
		Map<String,Object> m_col1=new HashMap<>();
		m_col1.put("chktime", "时间");
		title_colName.add(m_col1);
		try {
		    JSONArray array = JSONArray.fromObject(datarecord);
		    for (int i = 0; i < array.size(); i++) {
				Map<String,Object> m_col_x=new HashMap<>();
		        JSONObject jsonObject = array.getJSONObject(i);
		        String in = jsonObject.getString("itemname");//通过键值名获取字符串
		        String iu = jsonObject.getString("itemunit");//通过键值名获取字符串
		        m_col_x.put("para"+i, in+"  "+iu);
		        title_colName.add(m_col_x);
		    }
		}catch (Exception e){
			e.printStackTrace();
		}

		Map<String,Object> m_col2=new HashMap<>();
		m_col2.put("name", "巡检员");
		title_colName.add(m_col2);

		Map<String,Object> m_col3=new HashMap<>();
		m_col3.put("chkdes", "备注");
		title_colName.add(m_col3);
	}
	
	/**
	 * 作用：取得当前时间“当天1、一周7、一月30、一年365、所有0（默认）”的时间串组
	 * 参数：range
	 * 更新时间：2018-12-13
	 */
	public String[] getStimeAndEtime(String timerange) 
	{
	  	String[] startTimeAndEndTime=new String[2];
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c=Calendar.getInstance();//获取当前时间
		//1：当前的时间作为"endTime"
	   	Date endTime = new Date();
	   	startTimeAndEndTime[1]=sdf.format(endTime)+" 23:59:59";
	   	//2：根据参数获取开始时间"startTime"
	   	if(timerange.equals("1"))//一天
	   	{
		   	startTimeAndEndTime[0]=sdf.format(endTime)+" 00:00:00";
	   	}
	   	if(timerange.equals("7"))//一周
	   	{
	        c.setTime(endTime);
	        c.add(Calendar.DATE,-7);
	        Date startTime=c.getTime();
	        startTimeAndEndTime[0]=sdf.format(startTime)+" 00:00:00";
	   	}
	   	if(timerange.equals("30"))//一月
	   	{
	        c.setTime(endTime);
	        c.add(Calendar.MONTH,-1);
	        Date startTime=c.getTime();
	        startTimeAndEndTime[0]=sdf.format(startTime)+" 00:00:00";
	   	}
	   	if(timerange.equals("365"))//一年
	   	{
	        c.setTime(endTime);
	        c.add(Calendar.YEAR,-1);
	        Date startTime=c.getTime();
	        startTimeAndEndTime[0]=sdf.format(startTime)+" 00:00:00";
	   	}
		return startTimeAndEndTime;
	}

	@RequestMapping(value ="/importusers",method = RequestMethod.POST)
	@ResponseBody
	//public Json importusers(HttpSession session,HttpServletRequest request) 
	public Map<String,Object> importusers(HttpSession session,HttpServletRequest request,HttpServletResponse response) 
	{
		Map<String,Object> reMap=new HashMap<>();//返回值map
		//第一步：由excel获取用户集合，List<User>方式
		List<User> userList=new ArrayList<User>();//创建保存数据的list
		//第二步：获取中间表user_dep_pos使用的集合List<Map<String,Object>>的方式，
		List<Map<String,Object>> u_d_pList = new ArrayList<>();
		//第二步：获取中间表user_role使用的集合List<Map<String,Object>>的方式，
		List<Map<String,Object>> u_rList = new ArrayList<>();
		ExcelUtil.getDataListFromExcel(request, response, userList, u_d_pList, u_rList);//给这几个集合赋值
		int flag=userService.importUser(userList, u_d_pList, u_rList);
		if(flag>0)
		{
			reMap.put("message", "插入成功");
			reMap.put("status", "success");
		}
		else
		{
			reMap.put("status", "error");
		}
		return reMap;
	}
}
